---
title: Run a node for Taiko Hoodi from source
description: This guide will help you start up a node for the Taiko Hoodi network.
---

import {
  Aside,
  Card,
  Steps,
  Tabs,
  TabItem,
} from "@astrojs/starlight/components";

This tutorial explains how to run a node for our testnet Taiko Hoodi from source code.

## Building the Source Code

Please follow the [Building a Node from Source](/guides/node-operators/build-a-taiko-alethia-node-from-source) guide before continuing.
This guide presumes you have built the required images already (`taiko-geth` and `taiko-client`).

## Hardware Requirements

These are the recommended specs of a [mainnet Geth node](https://geth.ethereum.org/docs/getting-started/hardware-requirements); the actual requirements may be lower.

-       16GB RAM
-       2TB SSD
-       Quad-core CPU

Node operators should plan for future storage needs as the requirements will grow continuously.

### Create a JWT Secret

`taiko-geth` and `taiko-client` communicate over the standard Ethereum engine API authrpc. This communication is secured using a shared secret.

You will need to generate a shared secret in the form of a 32 byte hex string.

```bash
openssl rand -hex 32 > jwt.txt
```

### Start `taiko-geth`

It's generally better to start `taiko-geth` before you start `taiko-client` as you will encounter less error messages.

`taiko-geth` can be started without `taiko-client` and will wait until `taiko-client` begins communicating.

<Steps>

1.  Navigate to your `taiko-geth` directory

    Find the directory where you built the `taiko-geth` binary.

2.  Copy the JWT secret you generated into the `taiko-geth` directory.

    ```bash
    cp /path/to/jwt.txt .
    ```

3.  Start taiko-geth

        Use the following command to start `taiko-geth` in a default configuration.
        The JSON-RPC API will become available on port 28545.

        ```bash
            ./build/bin/geth \
                --taiko \
                --networkid 167013 \
                --gcmode archive \
                --datadir ./data/taiko-geth \
                --metrics \
                --metrics.expensive \
                --metrics.addr "0.0.0.0" \
                --bootnodes enode://eb5079aae185d5d8afa01bfd2d349da5b476609aced2b57c90142556cf0ee4a152bcdd724627a7de97adfc2a68af5742a8f58781366e6a857d4bde98de6fe986@34.44.53.195:30303,enode://b054002f068f30568aad39271462c053463edb4a3d3c19b71b475fa044805d7e2fda39c482eba183f9d1f76fb579a8e47c0c054bb819c2bbcb331c0aac7464c2@34.27.167.246:30303 \
                --authrpc.addr "0.0.0.0" \
                --authrpc.port 28551 \
                --authrpc.vhosts "*" \
                --authrpc.jwtsecret ./jwt.txt \
                --http \
                --http.api admin,debug,eth,net,web3,txpool,miner,taiko \
                --http.addr "0.0.0.0" \
                --http.port 28545 \
                --http.vhosts "*" \
                --ws \
                --ws.api admin,debug,eth,net,web3,txpool,miner,taiko \
                --ws.addr "0.0.0.0" \
                --ws.port 28546 \
                --ws.origins "*" \
                --gpo.ignoreprice "100000000" \
                --port 30304 \
                --syncmode full \
                --state.scheme=path
        ```

</Steps>

### Start `taiko-client`

This guide assumes you are running both `taiko-geth` and `taiko-client` on the same machine.

If you aren't, you can configure the ports and addresses so that the services can access each other.

<Steps>
1. Navigate to your `taiko-client` directory

    Find the directory where you built the `taiko-client` binary.

2.  Copy the JWT secret

    <Aside>
      This should be the *same* JWT secret you used in the previous step for
      `taiko-geth`.
    </Aside>

    ```bash
    cp /path/to/jwt.txt .
    ```

3.  Set environment variables

        The following URLs should be an Ethereum Hoodi node.

        You will need either an RPC provider, or run a full Ethereum Hoodi node yourself.

        <Aside type="tip">

    As of October 28, 2025, at slot 1,622,016, the Fusaka upgrade has rolled out to Ethereum Hoodi. With this upgrade comes [EIP-7594](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-7594.md),
    which introduces data sampling instead of full downloads; this means that if you are not running an Ethereum Hoodi semi-supernode or supernode beacon client,
    you L2 node may experience blob unavailability or chain divergence.

        Please configure your beacon client with the respective flags (detailed below) before the Fusaka hard fork date to avoid interruptions!
        - Lighthouse: **`--semi-supernode` or `--supernode`**
        - Teku: **`--p2p-subscribe-all-custody-subnets-enabled`**
        - Grandine: **`--subscribe-all-data-column-subnets`**
        - Lodestar: **`--supernode`**
        - Nimbus: **`--debug-peerdas-supernode`**

        Alternatively, you may set a `--blob.server` url if you wish to use a thirdparty or self hosted blob indexer service.
        This can be done with `$BLOB_SERVER_URL` in `simple-taiko-node`'s `.env`.

        </Aside>

        ```bash
        export L1_WS=...  # the WS address for the node to sync from.
        export L1_BEACON_URL=... # URL address for the L1 Beacon-node HTTP endpoint to use.
        ```

4.  Start taiko-client

        Use the following command to start `taiko-client` in a default configuration.

        You can find all other configurable flags by running `./bin/taiko-client driver`.

        This command assumes you've run the `taiko-geth` command as is, if you've changed ports please change them accordingly.

        <Aside type="tip">
        If you wish to enable a node without joining the preconfirmations p2p network, simply **remove all `p2p` and `preconfirmation` flags with the exception of `--p2p.sync` and `--p2p.checkPointSyncUrl`.**

        Please note that your node's chainhead will not be up-to-date with the preconfed blocks if you do not join the p2p network.
        </Aside>

        ```bash
            ./bin/taiko-client driver \
                --l1.ws ${L1_ENDPOINT_WS} \
                --l2.ws ws://l2_execution_engine:8546 \
                --l1.beacon ${L1_BEACON_HTTP} \
                --l2.auth http://l2_execution_engine:8551 \
                --taikoInbox 0xf6eA848c7d7aC83de84db45Ae28EAbf377fe0eF9 \
                --taikoAnchor 0x1670130000000000000000000000000000010001 \
                --preconfirmation.whitelist 0x83AE31678B9f255346Af4636B4726A84c3bD2886 \
                --preconfirmation.serverPort 9871 \
                --jwtSecret /data/taiko-geth/geth/jwtsecret \
                --p2p.sync \
                --p2p.checkPointSyncUrl https://rpc.hoodi.taiko.xyz
                --p2p.bootnodes enode://ea5b8a797985f500afa37ba03ce47b0039792a942f0ac9bee9fa19a7a5410273fe43b4e8a9a28fa42cdec1b6435deb809fcb79479c55cc2ddbaf02de7a83f456@35.239.142.239:4001?discport=30304,enode://404e9493066107431bdf3f47bbb360a353244a6069903c76928fca3067575f2adf62ef396b0a8a74696669ef53cab8373e38ddd9b3d3d2d76f356d2cd2708951@34.63.118.244:4001?discport=30304,enode://b2d094ade1ce68990878b197bf818bd41d5b32e4019d42dc63d91d7020f531532f063833e44e84f78792969f69fd5553370216703c40fcc0cb835f17177fbe07@34.63.52.157:4001?discport=30304 \
                --p2p.listen.ip 0.0.0.0 \
                --p2p.useragent taiko \
                --p2p.listen.tcp 4001 \
                --p2p.advertise.tcp 4001 \
                --p2p.listen.udp 30303 \
                --p2p.advertise.tcp 30303 \
                --p2p.peerstore.path /node-keys/peerstore \
                --p2p.discovery.path /node-keys/discv5 \
                --p2p.advertise.ip ${YOUR_EXTERNAL_IP} \
                --p2p.priv.raw ${PRIVATE_KEY}
        ```
        <Aside type="danger">
        `YOUR_EXTERNAL_IP` should be **publicly accessible** from the internet, at the UDP and TCP ports you advertise from. If it is not, your node will not join the P2P network correctly.
        </Aside>

        If you do not wish to set an external IP manually, you may instead replace the `--p2p.listen.tcp` and all lines after in the above command with `--p2p.nat`. This will automate discovery, and you do not need to manually set ports.

        We **highly recommend** that you configure these manually.

        Your node also needs a private key set to acquire a stable peer ID. (`--p2p.priv.raw`) This private key should be unique to each node: if you are running multiple, please use different ones for each node. **This private key does not need to hold eth or any valuables, it is simply to persist an identity.**

        You may alternatively set `--p2p.priv.path`, which should be a path to a file that contains the hex-encoded 32-byte private key for the peer ID. We recommend using `--p2p.priv.raw` for simplicity.

</Steps>

<Aside>
  The method to find your external IP can differ depending on your setup. For a
  personal machine, `curl ifconfig.me` might suffice; if you are running your
  node through Kubernetes you will need to set a static IP for your LoadBalancer
  service as pod IPs change on recreation. If you run into issues doing this,
  please reach out to us on
  [Discord](https://discord.com/channels/984015101017346058/1117285651394600960)!
</Aside>

### Ensure that the relevant ports are open on your machine

Whether you are running the node on a personal machine or a cloud provider's machine, you should ensure your the following ports on your machine are open and visible from the internet at your external IP: - TCP `4001` OR whichever port you set `--p2p.advertise.tcp` to. - UDP `30303` OR whichever port you set `--p2p.advertise.udp` to.

These ports **are required for p2p gossiping preconfirmed blocks**, so if it is not set you will only subscribe to the events that are emitted on chain. You may need to add additional port-forwarding rules in your firewall/router to enable discovery from the internet.

### Ensure that your node has joined the P2P network

To ensure that your node is actually configured correctly and has joined the P2P network for preconfirmations, please use `grep` to find logs regarding `peer tick`. You should find something that resembles the following:

```
INFO [07-30|18:37:38.168] Peer tick                                peersLen=4 peers="[...]" addrInfo="[...]" id=... advertisedUDP=52700 advertisedTCP=4001 advertisedIP=...
```

As long as `peersLen=X` is greater than or equal to 3, your node should have joined the P2P network correctly! If it is below that, please reach out to us on Discord for troubleshooting help.

### Syncing

Once you've started `taiko-geth` and `taiko-client` properly you should see them communicate with each other and start syncing.

Syncing can take several hours, depending on the size of the chain.

## Next Steps

<Card title="Troubleshooting" icon="error">
  If you run into any problems, please visit the [troubleshooting
  page](/guides/node-operators/node-troubleshooting) for help.
</Card>
